Mikä on operaattori “->” C ++: ssa?

-> ei ole operaattori. Se on itse asiassa kaksi erillistä operaattoria, - ja>.
Ehdollisen koodi pienentää x: tä palauttaen samalla x: n alkuperäisen arvon (ei vähennetty), ja vertaa sitten alkuperäistä arvoa 0: een operaattorin> avulla.
Ymmärtämiseksi paremmin lausunto voitaisiin kirjoittaa seuraavasti:
kun ((x--)> 0)
|
Tai jotain aivan muuta ... x liukuu arvoon 0.
kun (x - \
\
\
\
> 0)
printf ("% d", x);
Ei niin matemaattinen, mutta ... jokainen kuva maalaa tuhat sanaa ...
|
Se on hyvin monimutkainen operaattori, joten jopa ISO / IEC JTC1 (Joint Technical Committee 1) sijoitti kuvauksensa kahteen osaan C ++ -standardia.
Vielä leikattuna, ne ovat kaksi erilaista operaattoria: - ja> kuvattu vastaavasti C ++ 03 -standardin §5.2.6 / 2 ja §5.9.
|
Se vastaa
kun (x--> 0)
x-- (vähennyksen jälkeinen arvo) vastaa x = x-1, joten koodi muuttuu:
kun (x> 0) {
x = x-1;
// logiikka
}
x--; // Pylvään vähennys tehty, kun x <= 0
|
x voi mennä nollaan vielä nopeammin vastakkaiseen suuntaan:
int x = 10;
kun (0 <---- x)
{
printf ("% d", x);
}
8 6 4 2
Voit hallita nopeutta nuolella!
int x = 100;
kun (0 <-------------------- x)
{
printf ("% d", x);
}
90 80 70 60 50 40 30 20 10
;)
|
Sen
#include 
int main (mitätön) {
int x = 10;
kun (x--> 0) {// x siirtyy arvoon 0
printf ("% d", x);
}
paluu 0;
}
Pelkkä välilyönti saa asiat näyttämään hauskoilta, - vähennykset ja> vertaa.
|
->: n käytöllä on historiallinen merkitys. Vähennys oli (ja on joissakin tapauksissa edelleen) nopeampi kuin x86-arkkitehtuurin lisäys. Käyttämällä -> ehdottaa, että x on 0, ja vetoaa matemaattisen taustan omaaviin.
|
kun (x--> 0)
miten se on jäsennelty.
|
Täysin nörtti, mutta käytän tätä:
#define as; while
int main (int argc, char * argv [])
{
int n = atoi (argv [1]);
tee printf ("n on% d \ n", n) kuten (n -> 0);
paluu 0;
}
|
Yhdessä luemassani kirjassa (en muista oikein, mikä kirja) sanottiin: Kääntäjät yrittävät jäsentää lausekkeita suurimpaan tunnukseen vasemman oikean säännön avulla.
Tässä tapauksessa lauseke:
x -> 0
Jäsennys suurimpiin merkkeihin:
tunnus 1: x
tunnus 2: -
tunnus 3:>
merkki 4: 0
päättele: x--> 0
Sama sääntö koskee tätä lauseketta:
a ----- b
Jäsennyksen jälkeen:
tunnus 1: a
tunnus 2: -
tunnus 3: -
tunnus 4: -
tunnus 5: b
päättele: (a -) - - b
Toivon, että tämä auttaa ymmärtämään monimutkaisen lausekkeen ^^
|
Tämä on täsmälleen sama kuin
kun (x--)
{
printf ("% d", x);
}
ei-negatiivisille numeroille
|
Joka tapauksessa meillä on nyt "menee" -operaattori. "->" on helppo muistaa suuntana, ja "kun x menee nollaan" on merkitys-suora.
Lisäksi se on vähän tehokkaampi kuin "for (x = 10; x> 0; x -)" joillakin alustoilla.
|
Tämä koodi vertaa ensin x: tä ja 0: ta ja vähentää sitten x: tä. (Sanottiin myös ensimmäisessä vastauksessa: Vähennät x: tä ja verrataan sitten x: tä ja 0: ta> -operaattoriin.) Katso tämän koodin lähtö:
9 8 7 6 5 4 3 2 1 0
Nyt verrataan ensin ja vähennetään sitten näkemällä 0 lähdössä.
Jos haluamme ensin vähentää ja sitten verrata, käytä tätä koodia:
#include 
int main (mitätön)
{
int x = 10;
kun (--x> 0) // x siirtyy arvoon 0
{
printf ("% d", x);
}
paluu 0;
}
Tämä tuotos on:
9 8 7 6 5 4 3 2 1
|
Kääntäjä tulostaa 9876543210, kun suoritan tämän koodin.
#include 
int main ()
{
int x = 10;
kun (x -> 0) // x siirtyy arvoon 0
{
vakio :: cout << x;
}
}
Odotetusti. While (x--> 0) tarkoittaa tosiasiallisesti while (x> 0). X - vähentää vähennyksiä x.
kun (x> 0)
{
x--;
vakio :: cout << x;
}
on erilainen tapa kirjoittaa sama asia.
On hienoa, että alkuperäinen näyttää kuitenkin "kun x menee 0".
|
- ja> välistä puuttuu välilyönti. x vähennetään jälkikäteen, ts. vähennetään tarkistettuaan ehto x> 0?
|
- on vähennysoperaattori ja> on suurempi kuin operaattori.
Näitä kahta operaattoria käytetään yhtenä yhtenäisenä ->.
|
Se on kahden operaattorin yhdistelmä. Ensinnäkin - on arvon vähentämiseen ja> tarkistaa, onko arvo suurempi kuin oikeanpuoleinen operandi.
#include 
int main ()
{
int x = 10;
kun (x--> 0)
printf ("% d", x);
paluu 0;
}
Tulos on:
9 8 7 6 5 4 3 2 1 0
|
Itse asiassa x vähentää vähennystä ja tämän ehdon kanssa tarkistetaan. Se ei ole ->, se on (x--)> 0
Huomaa: x: n arvo muuttuu kun ehto on tarkistettu, koska se vähentää vähennystä. Joitakin vastaavia tapauksia voi myös esiintyä, esimerkiksi:
-> x -> 0
++> x ++> 0
-> = x -> = 0
++> = x ++> = 0
|
C ja C ++ noudattavat "maksimaalisen munch" -sääntöä. Samalla tavalla --- b käännetään muotoon (a--) - b, tapauksessasi x -> 0 tarkoittaa (x -)> 0.
Sääntö sanoo lähinnä, että siirtyminen vasemmalta oikealle, lausekkeet muodostetaan ottamalla maksimimäärä merkkejä, jotka muodostavat kelvollisen lausekkeen.
|
Miksi kaikki komplikaatiot?
Yksinkertainen vastaus alkuperäiseen kysymykseen on vain:
#include 
int main ()
{
int x = 10;
kun (x>0)
{
printf ("% d", x);
x = x-1;
}
}
Se tekee saman asian. En sano, että sinun pitäisi tehdä se näin, mutta se tekee saman asian ja olisi vastannut kysymykseen yhdessä viestissä.
X-- on vain lyhenne edellä mainituille ja> on vain normaali suurempi kuin operaattori. Ei suurta mysteeriä!
Nykyään on liian paljon ihmisiä, jotka tekevät yksinkertaisia ​​asioita monimutkaisiksi;)
|
Tavallisella tavalla määritettäisiin ehto while-silmukan sulkeissa () ja päättävä ehto aaltosulkeissa {}, mutta -> määrittelee molemmat kerralla.
Esimerkiksi:
int abc (mitätön)
{
int a = 5
while ((a--)> 0) // Vähennys ja vertailu molemmat kerralla
{
// Koodi
}
}
Tämä vähentää a: ta ja suorittaa silmukan, kun a on suurempi kuin 0.
Perinteisesti se olisi kuin:
int abc (mitätön)
{
int a = 5;
kun (a> 0)
{
a--;
// Koodi
}
a--;
}
Molemmilla tavoilla teemme saman asian ja saavutamme samat tavoitteet.
|
(x -> 0) tarkoittaa (x--> 0).
Voit käyttää (x ->) -lähtöä: 9 8 7 6 5 4 3 2 1 0
Voit käyttää (- x> 0) Se on keskiarvo (--x> 0) Tulos: 9 8 7 6 5 4 3 2 1
Voit käyttää
(- \
\
x> 0)
Lähtö: 9 8 7 6 5 4 3 2 1
Voit käyttää
(\
\
x -> 0)
Lähtö: 9 8 7 6 5 4 3 2 1 0
Voit käyttää
(\
\
x -> 0
\
\
)
Lähtö: 9 8 7 6 5 4 3 2 1 0
Voit käyttää myös
(
x
->
)
Lähtö: 9 8 7 6 5 4 3 2 1 0
Samoin voit kokeilla monia menetelmiä tämän komennon suorittamiseksi onnistuneesti.
|
Tässä - on unary post decrement operaattori.
kun (x--> 0) // x siirtyy arvoon 0
{
printf ("% d", x);
}
Alussa tila arvioidaan
(x> 0) // 10> 0
Koska ehto on totta, se menee silmukkaan, jolla on vähennetty arvo
x-- // x = 9
Siksi ensimmäinen painettu arvo on 9
Ja niin edelleen. Viimeisessä silmukassa x = 1, joten ehto on tosi. Yksittäisen operaattorin mukaan arvoksi muutettiin x = 0 tulostuksen aikana.
Nyt x = 0, joka arvioi ehdon (x> 0) vääräksi ja while-silmukka poistuu.
|
Tämä -> ei ole ollenkaan operaattori. Meillä on operaattori kuten ->, mutta ei kuten ->. Se on vain väärä tulkinta hetkestä (x--> 0), mikä tarkoittaa yksinkertaisesti sitä, että x: llä on vähennyksen jälkeinen operaattori ja tämä silmukka käy, kunnes se on suurempi kuin nolla.
Toinen yksinkertainen tapa kirjoittaa tämä koodi olisi while (x--). While-silmukka pysähtyy aina, kun se saa väärän ehdon, ja tässä on vain yksi tapaus, ts. 0. Joten se pysähtyy, kun x-arvo vähennetään nollaan.
|
Erittäin aktiivinen kysymys. Ansaitse 10 mainetta vastaamiseksi tähän kysymykseen. Maineen vaatimus auttaa suojaamaan tätä kysymystä roskapostilta ja vastaamattomuudelta.
Eikö vastausta etsit? Selaa muita kysymyksiä, jotka on merkitty c ++ c -operaattoreiden koodin muotoilustandardien noudattamiseen tai kysy omaa kysymystäsi.